<%--
	fileName      : rolemgmt.jsp
	author        : KFZX-tangk
	createDate    : 2010-7-2  上午08:42:04
	lastModifier  : KFZX-tangk
	lastModifyDate: 2010-7-2  上午08:42:04
	description   : 角色管理模块
--%>

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib uri="ctp-tag" prefix="ctp"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>角色管理</title>
<ctp:include
	items='borderlayout,toolbar,textfield,button,editable,tabletree,combobox,form,validator,textarea,label,gridlayout,groupbox,menus,panel,grid,statusbar,radiogroup,checkbox,checkboxgroup,message_ex,datepicker,multiselect' />
<%@ include file="/uniform_attestation/ssicPub.jsp"%>
<%@ include file="/systemgmt/authExt.jsp"%>
<script type='text/javascript' kind='variant'>		  
		     //================================UI变量定义片段============================================================
             var layout;//页面框架布局器
             var toolbarSearchT;//搜索文本框
             var toolbar;//角色工具栏
             var grid;//角色列表表体
             var prvLayout;//表单中角色权限的布局
             var mlayout;//表单的主布局
             var form;//实现角色管理功能的表单
             var retform;//用于返回的表单
             var formPanel;//新增、修改、显示详细信息时显示的面板
             var menuPanel;//角色菜单调整时显示的面板
             var menuTb;//角色菜单调整时显示的工具栏
             var tableTree;//角色菜单表格树
             var lBranch;//创建机构组件
             var tId;//角色编号组件
             var tName;//角色名称组件
             var cgLevel;//可使用级别组件
             var rgPriv;//角色权限radiogroup组件
             var cbPriv;//角色权限combobox组件
             var taDesc;//角色描述组件               

             //新增互斥角色
             var exclusionMultiselect;       
        </script>
<script type='text/javascript' kind='event'>
            //================================函数定义片段============================================================
            var roleLev;//角色级别设置结果
            var privAll='0';//角色权限中是否设置为全部机构，是为1，否为0，默认未设置
            var privSelf='0';//角色权限中是否设置为本机构，是为1，否为0，默认未设置
            var privOth='0';//角色权限中设置为本机构后，在下拉列表选择的可维护级别，可维护下属x级机构，则结果为x，默认未设置
            var state='info';//用户操作标识，info表示显示详细信息,add表示新增,modify表示修改,menu表示角色菜单调整.默认显示详细信息
            var bId='';//传入的机构ID
            var bName='';//传入的机构名称
            var bLev=0;//传入的机构级别
            var maxLev=0;
            var levs = 0;//机构层级深度
            var isSelected=false;//是否选择了角色标识
            var menuShow=false;//是否显示了角色菜单面板标识
            var msgSuc='';//操作成功显示信息
            var msgErr='';//操作失败显示信息
            var extProperty;//扩展属性
            var extFlag="0";//扩展属性标识,0表示没有扩展属性,1表示有扩展属性 
            var gridurl="";//查询角色列表URL
            var tabletreeurl;//查询角色菜单URL
            var cgItems=[];//可使用级别checkboxgroup的items参数
            var cbItems=[];//角色权限combobox的items参数
            var menuRoleId='';//进行角色菜单调整的角色编号
            var hasError=false;
            /**
             * 页面加载的时候进行初始化的函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function init(){
            	var _mContext = "rolemgmt.jsp -> init()";
            	try{
            		//保存传入的机构ID、机构名称、机构级别等参数
	            	bId ='<ctp:out name="branchId" />';
	            	bName='<ctp:out name="branchName" />';
	            	bLev='<ctp:out name="branchLevel" />';
	            	maxLev='<ctp:out name="flowCtx.maxLevel" />';
	            	//初始化查询角色菜单URL
	            	gridurl='<ctp:url href="rolemgmt.flowc" flowActionName="rolequerylist" params="branchId=branchId;branchLevel=branchLevel;language=sessCtx.Language;" />';
	            	//取得机构层级深度
	                var ret = ctp.data.getJSON('<ctp:url href="rolemgmt.flowc" flowActionName="getbranchdepop" params="branchId=branchId;"/>');
	                if(ret[0].out_flag && ret[0].out_flag=='0'){//成功
	                	levs = ret[0].branchDep;
	                }else{//失败
	                	var errMsg='<ctp:label key="init_branch_dep_fail"/> <ctp:label key="errorCode"/>:'+ret[0].errorCode+',<ctp:label key="errorMsg"/>:'+ret[0].errorMsg;
	                	ctpMSB.error({title:'<ctp:label key="operation_result_title" />',message: errMsg});
	                	levs = 0;
	                	hasError=true;
	                	return;
	                }
	                //初始化机构级别参数
	                cgItems.push({id:'checkbox0',label:'<ctp:label key="this_branch" />',value: '1',checked: true});//本机构
	           	 	cbItems.push({text:'<ctp:label key="select_role_level" />',value:'0',selected: true});//请选择机构级别
	           	 	for(var i=0;i<levs;i++){
	           			cgItems.push({id:'checkbox'+(i+1),label:'<ctp:label key="underline" />'+(i+1)+'<ctp:label key="level" />',value: '1'});//下属x级机构
	           		 	cbItems.push({text:'<ctp:label key="can_manage" /><ctp:label key="underline" />'+(i+1)+'<ctp:label key="level" />',value: (i+1)+''});//可维护下属x级机构
	           	 	}
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 设置修改、删除、角色菜单调整按钮的有效性
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function setMDADisable(flag){
            	var _mContext = "rolemgmt.jsp -> setMDADisable()";
            	try{
            		toolbar.setDisable("btnModify",flag,"left");//修改按钮
                    toolbar.setDisable("btnDelete",flag,"left");//删除按钮
                    toolbar.setDisable("btnAdjust",flag,"left");//菜单调整按钮
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 设置表单各域的值
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function setFormFields(){
            	var _mContext = "rolemgmt.jsp -> setFormFields()";
            	try{
            	    var temp=grid.getSelectedData()[0];//选择表格行的数据
            	    if(typeof temp == 'undefined'){return;}           	    
            	    lBranch.setText(temp.branchName);//创建机构	              
            	    tId.setValue(temp.id);//角色编号
            	    tName.setValue(temp.name);//角色名称
					var c,i,_items=cgLevel.getItems();
					for(i=0;i<_items.length;i++){//设置可使用级别
						_items[i].setChecked(false);
						var ttt=i+parseInt(bLev)-1;
            		    c = temp.roleLevel.charAt(ttt);
            		    if(typeof(c)!= 'undefined' && c=='1'){
            			    _items[i].setChecked(true);
            		    }
					}
            	    if(temp.privilegeAll=='1'){ //设置角色权限
            		    rgPriv.setItemChecked('radioAll',true);
            	    }else{
            		    if(temp.privilegeSelf=='1'){
            			    rgPriv.setItemChecked('radioThis',true);
            			    cbPriv.setValue(temp.privilegeOther);
            		    }else{
            			    rgPriv.setItemChecked('radioNormal',true);
            		    }
            	    }

            	  //加载所有角色到互斥角色列表中
            		exclusionMultiselect.reloadData({url:'<ctp:url href="rolemgmt.flowc" flowActionName="getexclulist" />&branchId=' + bId + '&branchLevel=' + bLev + '&curRoleId=' + temp.id});
            	    
            	    taDesc.setValue(temp.description); //角色描述
            	    if(extFlag=="1"){//如果有扩展数据
            		    var extData=ctp.data.getJSON('<ctp:url href="rolemgmt.flowc" flowActionName="queryRoleExtData"/>&objId='+temp.id);//取得角色表扩展属性数据
            		    if(extData.length>0 && extData[0].errorCode){ //查询扩展属性数据出错
                        	ctpMSB.error({message:'<ctp:label key="query_role_extdata_error"/>,<ctp:label key="errorCode"/>:'+extData[0].errorCode+',<ctp:label key="errorMsg"/>:'+extData[0].errorMsg});
                        }
            	        setExtValue(form,extProperty,extData);//设置扩展数据}	      
            	    }
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 页面加载的时候进行初始化的函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function displayFinish(){
            	var _mContext = "rolemgmt.jsp -> displayFinish()";
            	try{
            		if(hasError){return;}
            		form.setDisableAll(true);//设置不可编辑
                    menuTb.jqDom.hide();//隐藏角色菜单调整工具栏
                    menuPanel.jqDom.hide();//隐藏角色菜单调整面板
                    setMDADisable(true);//禁用修改、删除、角色菜单调整按钮
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }           
            /**
             * 查询机构扩展属性并在表单中创建扩展属性
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function queryExtProperty(){
            	 var _mContext = "rolemgmt.jsp -> queryExtProperty()";
                 try {
                 	  if(hasError){return;}
            	      extProperty=ctp.data.getJSON('<ctp:url href="rolemgmt.flowc" flowActionName="queryRoleExtProperty"/>');//查询机构表扩展属性	
                      if(extProperty.length>0){
                          if(extProperty[0].errorCode){ //查询扩展属性出错
                              ctpMSB.error({message:'<ctp:label key="query_role_extlist_error"/>,<ctp:label key="errorCode"/>:'+extProperty[0].errorCode+',<ctp:label key="errorMsg"/>:'+extProperty[0].errorMsg});
                          }else{                 	      
                     	      var count=extProperty[0].totalNum;
                     	      if(count>0){
                     		      extFlag="1";//修改扩展属性标识                     		
                     		      form.setHiddenValue("ext_flag","1");//设置表单中扩展属性标志的值              	                    	                       	
                     		      $.each(extProperty, function(i, ext){
                       		          if(i>0){//忽略第一个数据totalNum
                           		          var extProId=ext.id;//扩展属性ID
                       		              var extProName=ext.name;//扩展属性名称
                       		              var extProTable=ext.table;//扩展表
                       		              var extProType=ext.type;//扩展属性类型,0：textfield，1：textarea，2：number，3：date，4：combobox，5：radiogroup，6：checkboxgroup 
                       		              var extProDefaultValue=ext.defaultvalue;//缺省值，当属性为combobox、radiogroup、checkboxgroup 类型时，代表备选项，以分号";"分隔，放置在第一位的为缺省显示项 
                       		              var extProRequired=ext.required;//是否为必填，1：必填，0：可空
                       		              var extProDesc=ext.desc;//属性描述
                       		              var extProValidcheck=ext.validcheck;//合法性校验
                       		              var extProFormat=ext.format;//数据格式
                       		              cteateExtItem(form,mlayout,extProId,extProName,extProType,extProDefaultValue,extProRequired,extProDesc,extProValidcheck,extProFormat);//在表单中创建扩展属性 
                       		          }
                       	         });
                     	     }else{
                     		     extFlag="0";//修改扩展属性标识
                     		     form.setHiddenValue("ext_flag","0");//设置新增表单扩展属性标志                       		
                     	     }                     	
                        
                        }
                    }
                 }catch (e) {
                     ctp.core.log.err(_mContext, e.message);
                 }  
            }
            /**
             * 角色权限改变的响应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function privChange(){
            	var _mContext = "rolemgmt.jsp -> privChange()";
            	try{
            		if(rgPriv.getValue()=='self'){//是否选中本机构
           				state != 'info' && state != 'menu' && cbPriv.setDisable(false);//激活下拉框
           			 	privAll="0";//所有机构标识
           			 	privSelf="1";//本机构标识
           		 	}else{
           				cbPriv.setSelectedByIndex(0);//重置下拉框
           			 	state != 'info' && state != 'menu' && cbPriv.setDisable(true);//禁用下拉框
           			 	privSelf="0";//本机构标识
           			 	privAll=(rgPriv.getValue()=='all')?"1":"0";//所有机构标识
           		 	}
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 根据用户的设置生成角色级别
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
             function getRoleLevel(){
            	 var _mContext = "rolemgmt.jsp -> getRoleLevel()";
            	 try{
            		 var _result=[];
            		 var _items=cgLevel.getItems();
            		 for(var i=maxLev;i>_items.length;i--){
                 			_result.push('0');													
             		 }            		 
            		 for(var i=0;i<_items.length;i++){
            		 	if(_items[i].isChecked()==true){
                			_result.push('1');													
                		}else{
                			_result.push('0');
                		}
            		 }
                     return _result.join('');
                 }catch(e){
                	 ctp.core.log.err(_mContext, e.message);
                 }
            }
            /**
             * 重置表单函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function clear(){
            	var _mContext = "rolemgmt.jsp -> clear()";
            	try{
             		tId.setValue('');
             		tName.setValue('');
             		cgLevel.setGroupChecked(false);
             		rgPriv.setItemChecked('radioNormal',true);
             		cbPriv.setSelectedByIndex(0);
             		taDesc.setValue('');
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 工具栏新增按钮对应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
             function addRole(){
            	var _mContext = "rolemgmt.jsp -> addRole()";
            	try{
            		if(state=='menu'){//从角色菜单调整切换到新增角色
            			//menuTb.jqDom.hide();//隐藏角色菜单调整工具栏
            			//menuPanel.getJqDom().hide();//隐藏角色菜单调整面板
            			//formPanel.getJqDom().show();//显示存放表单的面板
            			ctp.util.hide(menuTb);
            			ctp.util.hide(menuPanel);
            			ctp.util.show(formPanel);
            		}
            		state='add';
            		form.setDisableAll(false);//激活表单中的组件
            		cbPriv.setDisable(true);//禁用下来框
            		formPanel.setTitle('<ctp:label key="add_role"/>');//新增
            		form.reset();//表单重置
            		clear();
            		lBranch.setText(bName);
            		cgLevel.setItemChecked('checkbox0',true);//可使用级别默认本机构
            		document.roleForm.flowActionName.value="addroleop";//ctp:form切换到新增op
            		msgSuc='<ctp:label key="add_role_success"/>';//新增成功
            		msgErr='<ctp:label key="add_role_fail"/>';//新增失败

            		//加载所有角色到互斥角色列表中
            		exclusionMultiselect.reloadData({url:'<ctp:url href="rolemgmt.flowc" flowActionName="getexclulist" />&branchId=' + bId + '&branchLevel=' + bLev + '&curRoleId='});
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 工具栏修改按钮对应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-liux           
             */
             function modifyRole(){
            	var _mContext = "rolemgmt.jsp -> modifyRole()";
            	try{
                	if(grid.getSelectedData()[0]!=null){
                		if(state=='menu'){//从角色菜单调整切换到修改角色
            				//menuTb.jqDom.hide();
            				//menuPanel.getJqDom().hide();
            				//formPanel.getJqDom().show();
            				ctp.util.hide(menuTb);
            				ctp.util.hide(menuPanel);
            				ctp.util.show(formPanel);
            			}
                		state='modify';
                		//setFormFields();
            			formPanel.setTitle('<ctp:label key="modify_role"/>');//修改角色
            			form.setDisableAll(false);//激活表单中的组件
            			if(cbPriv.getValue()=="0"){
            	 			cbPriv.setDisable(true);
            			};
            			tId.setDisable(true);//禁止修改角色编号
            			document.roleForm.flowActionName.value="modifyroleop";//ctp:form切换到修改op
            			msgSuc='<ctp:label key="modify_role_success"/>';//修改成功
            			msgErr='<ctp:label key="modify_role_fail"/>';//修改失败
            		}else{
            			ctpMSB.alert({message:'<ctp:label key="select_modify_role"/>'});//请选择要修改的角色！
            		}
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 工具栏删除按钮对应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
             function deleteRole(){
            	var _mContext = "rolemgmt.jsp -> deleteRole()";
            	try{
            		var temp=grid.getSelectedData()[0];//选择行的数据
            		if(temp!=null){
            			if(temp.id.trim()=='200'){
            				ctpMSB.alert('<ctp:label key="can_not_delete_manager"/>');
            				return;
            			}
            			//查询该角色关联的用户数
            			var ret = ctp.data.getJSON('<ctp:url href="rolemgmt.flowc" flowActionName="qryusernum"/>&roleId='+temp.id);
            			if(ret[0].out_flag && ret[0].out_flag=='0'){//成功
	                		if(parseInt(ret[0].usr_num)>0){
	                			ctpMSB.alert({message:'<ctp:label key="notice_connect_with_this_role"/>'});
            				}
	                	}else{//失败
	                		ctpMSB.alert('<ctp:label key="get_role_user_num_fail"/> <ctp:label key="errorCode"/>:'+ret[0].errorCode+',<ctp:label key="errorMsg"/>:'+ret[0].errorMsg);
	                	}
            			//确认信息：若删除此角色，将删除它的所有对应关系，是否继续?
            			ctpMSB.confirm({message:' <ctp:label key="ifdel_role_stillcontinue"/>',handler:function(tp){
            				if(tp=='ok'){//确认
                				function delRole(){
                					var data = ctp.data.getJSON('<ctp:url href="rolemgmt.flowc" flowActionName="deleteroleop"/>&roleId='+temp.id+'&objId='+temp.id);
                					if(data[0].out_flag && data[0].out_flag=='0'){
                						//结果提示：删除成功
                						ctpMSB.succeed({title:'<ctp:label key="operation_result_title"/>',message:'<ctp:label key="delete_role_success"/>'});
                	                	grid.loadData(gridurl);
                	                	setMDADisable(true);
                					}else{
                						//结果提示：删除失败
                						var errMsg='<ctp:label key="delete_role_fail"/> <ctp:label key="errorCode"/>:'+data[0].errorCode+',<ctp:label key="errorMsg"/>:'+data[0].errorMsg;
                						ctpMSB.error({title:'<ctp:label key="operation_result_title"/>',message:errMsg});
                					}
                				}                				 
                				if('true'=='<ctp:out name="servCtx.enableSSIC"/>' && '1'=='<ctp:out name="servCtx.authFlag"/>'){//判断是否需要统一认证双人授权
			            		    ssicAuth('<ctp:out name="fullPath"/>rolemgmt.flowc','deleteroleop',delRole);//调用统一认证双人授权接口         
			            		}else{
			            			delRole();
			            		}
            				}
            			}});
            		}else{
            			ctpMSB.alert({message:'<ctp:label key="select_del_role"/>'});//请选择要删除的角色！
            		}
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 工具栏角色菜单调整按钮对应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function adjustMenu(){
            	var _mContext = "rolemgmt.jsp -> adjustMenu()";
            	try{
            		var temp=grid.getSelectedData()[0];//选择行的数据
	            	if(temp!=null){//选中了表格的某条记录
	            		state='menu';
	            		//formPanel.getJqDom().hide();//隐藏存放表单的面板
	            		//menuTb.jqDom.show();//显示角色菜单调整工具栏
	            		//menuPanel.getJqDom().show();//显示角色菜单调整面板
	            		ctp.util.hide(formPanel);
	            		ctp.util.show(menuTb);
	            		ctp.util.show(menuPanel);
	            		//显示角色菜单
	            		tabletreeurl='<ctp:url href="rolemgmt.flowc" flowActionName="qryrolemenu" params="branchId=branchId;Language=sessCtx.Language;" />&roleId='+temp.id+'&roleLevel='+temp.roleLevel;
	            		tableTree.reload({url:tabletreeurl});
	            		tableTree.refreshJsonVal();
	            		menuRoleId=temp.id;
	            	}else{
	            		//请选择要进行菜单功能调整的角色！
	            		ctpMSB.alert({message:'<ctp:label key="select_menu_funtion_modify_role"/>'});
	            	}
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 设置表单组件详细信息
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function setDetailValue(){
            	var _mContext = "rolemgmt.jsp -> setDetailValue()";
            	try{
            		state='info';
            	    form.setDisableAll(true);
            	    formPanel.setTitle('<ctp:label key="role_detail_info"/>');
            	    clear();
					setFormFields();
            	    isSelected=true;
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 更新角色菜单信息
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function refreshRoleMenu(){
            	var _mContext = "rolemgmt.jsp -> refreshRoleMenu()";
                try{
	            	var temp=grid.getSelectedData()[0];//选择行的数据
	            	tabletreeurl='<ctp:url href="rolemgmt.flowc" flowActionName="qryrolemenu" params="branchId=branchId;Language=sessCtx.Language;" />&roleId='+temp.id+'&roleLevel='+temp.roleLevel;
	            	tableTree.reload({url:tabletreeurl});
	            	tableTree.refreshJsonVal();
	            	menuRoleId=temp.id;
                }catch(e){
                	ctp.core.log.err(_mContext, e.message);
                }
            }
            /**
             * 在角色列表中点选角色记录时执行的函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function recordClicked(){
            	ctp.util.closeAllPrompt();//清除所有验证提示信息
				//修复角色菜单调整时tabletree没有关闭，选择另一个角色再进行角色菜单调整时下拉框出现重复选项的bug modify by kfzx-lvsx 20130620
            	tableTree.prepareSubmit();
            	switch(state){
            	case 'info':
            	case 'add':
            	case 'modify':
            		setDetailValue();//之前状态为角色详细信息、新增、修改,则设置选中角色的详细信息
            		break;
            	case 'menu':
            		refreshRoleMenu();//之前状态为角色菜单调整,则刷新角色菜单
            		break;
            	default:
            		break; 
            	}
            	setMDADisable(false);
            	var temp=grid.getSelectedData()[0];//选择行的数据
            	if(temp.id.trim()=='200'){//选中了系统管理员
            		toolbar.setDisable("btnDelete",true,"left");//禁用删除按钮
            	}else{
            		toolbar.setDisable("btnDelete",false,"left");//禁用删除按钮
            	}
            } 
            /**
             * 工具栏搜索按钮对应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function roleToolbarSearch(){
            	 var _mContext = "rolemgmt.jsp -> roleToolbarSearch()";
            	 try {
            	 	var _searchValue=toolbarSearchT.getValue();//取得搜索的文本
					if(_searchValue.trim() != ''){//搜索文本不为空，则搜索角色名称带有关键字的记录
						var tmpUrl = '<ctp:url href="rolemgmt.flowc" flowActionName="searchroleop" params="branchId=branchId;branchLevel=branchLevel;" />&keyword='+encodeURIComponent(_searchValue);
						grid.loadData(tmpUrl);
					}else{//否则重新加载全部记录
						grid.loadData(gridurl);
					}
					setMDADisable(true);
            	 }
            	 catch (e) {
                     ctp.core.log.err(_mContext, e.message);
                 }            	 
            }
            /**
             * 表单提交按钮执行函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function roleFormSubmit(){
            	 var _mContext = "rolemgmt.jsp -> roleFormSubmit()";
            	 try {
            	     //设置各隐藏域
            	     
            	     //增加互斥角色相关内容
            	     var _val = exclusionMultiselect.getValue();
					 var _valArray = _val.split(',');
					 var _varTurnArray = [];
					 var _val = "";
					 for(var i = 0; i<_valArray.length; i++){
						 _val = _valArray[i];
						 if(_val !== ""){
							 _varTurnArray.push('{"id":"' + _val + '"}');
						 }
					 }
					 var _varTurn = '[' + _varTurnArray.join(",") + ']';
					 form.setHiddenValue("refRoleExclu",_varTurn);
					 
            		 form.setHiddenValue("branchId",bId);
	       			 form.setHiddenValue("privilegeSelf",privSelf);
	       			 form.setHiddenValue("privilegeAll",privAll);
	       			 privOth=cbPriv.getValue();
	       			 form.setHiddenValue("privilegeOther",privOth);
	       			 roleLev=getRoleLevel();
	       			 form.setHiddenValue("roleLevel",roleLev);
	       			 //提交表单
	       			 if(form.submitCheck()==false){ //表单校验
                    	 return;
                	 }
            		 if('true'=='<ctp:out name="servCtx.enableSSIC"/>' && '1'=='<ctp:out name="servCtx.authFlag"/>'){//判断是否需要统一认证双人授权
            		     ssicAuth(document.roleForm.action,form.getHiddenInputValue("flowActionName"),function (){form.submit();});//调用统一认证双人授权接口 
            		 }else{
            			 form.submit();
            		 }            		 
            	 }
            	 catch (e) {
                     ctp.core.log.err(_mContext, e.message);
                 }            	 
            }
            /**
             * 表单重置按钮执行函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function roleFormReload(){
            	 var _mContext = "rolemgmt.jsp -> roleFormReload()";
            	 try {
            	 	if(state=='add'){
            	 		form.reset();
            	 	}
            	 	if(state=='modify'){
            	 		setFormFields();
            			if(rgPriv.getValue()!="self"){
            				cbPriv.setValue('0');
            	 			cbPriv.setDisable(true);
            			};
            			//tId.setDisable(true);//禁止修改角色编号
            	 	}
            	 }
            	 catch (e) {
                     ctp.core.log.err(_mContext, e.message);
                 }            	 
            }
            /**
             * 表单提交成功后执行的函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function roleFormSucc(data){
            	 var _mContext = "rolemgmt.jsp -> roleFormSucc()";
            	 try {
            		 if(data[0].out_flag=='0'){//提交成功 
            		 	   //结果提示：新增/修改成功                                               
	                       ctpMSB.succeed({title:'<ctp:label key="operation_result_title" />',message: msgSuc});
	                       grid.loadData(gridurl);//重新加载表格数据
	                       setMDADisable(true);
	                       exclusionMultiselect.delAllItems();
	                       form.setDisableAll(true);
	                  }else{
	                	  msgErr+=',<ctp:label key="errorCode"/>:'+data[0].errorCode+',<ctp:label key="errorMsg"/>:'+data[0].errorMsg;
	                	  //结果提示：新增/修改失败；错误码：xxx；错误原因：xxx；
	                      ctpMSB.error({title:'<ctp:label key="operation_result_title" />',message: msgErr});
	                  } 
            	 }
            	 catch (e) {
                     ctp.core.log.err(_mContext, e.message);
                 }            	 
            }
            /**
             * 返回表单提交函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function retFormSubmit(){
            	var _mContext = "rolemgmt.jsp -> retFormSubmit()";
            	try{
            		retform.submit();
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 角色菜单调整确定按钮响应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function menuConfirm(){
            	var _mContext = "rolemgmt.jsp -> menuConfirm()";
            	try{
                	function adjust(){
                		$.editable.submitUnit(tableTree);//允许最后一次修改不回车直接提交
                		var menuData = ctp.data.jsonToStr(tableTree.getJsonVal());
                		if(!tableTree.getJsonVal().length){return;}//判断json内容是否为空，临时这样写，等有方法判断之后替换
		            	var retData = ctp.data.getJSON('<ctp:url href="rolemgmt.flowc" flowActionName="modifyrolemenuop"/>&roleId='+menuRoleId,{"json.menuPrvList":ctp.data.jsonToStr(tableTree.getJsonVal())});
                		if(retData[0].out_flag && retData[0].out_flag=='0'){
                			//结果提示：角色菜单调整成功
                			ctpMSB.succeed({title:'<ctp:label key="operation_result_title"/>',message:'<ctp:label key="adjust_rolemenu_success"/>'});
                	    	tableTree.reload({url:tabletreeurl});;//重新加载菜单
		                	$.editable.refreshJson();
                	    	tableTree.refreshJsonVal();
                		}else{
                			//结果提示：角色菜单调整失败
                			var errMsg='<ctp:label key="adjust_rolemenu_fail"/> <ctp:label key="errorCode"/>:'+retData[0].errorCode+',<ctp:label key="errorMsg"/>:'+retData[0].errorMsg;
                			ctpMSB.error({title:'<ctp:label key="operation_result_title"/>',message:errMsg});
                		}
                	}
                	if('true'=='<ctp:out name="servCtx.enableSSIC"/>' && '1'=='<ctp:out name="servCtx.authFlag"/>'){//判断是否需要统一认证双人授权
			        	ssicAuth('<ctp:out name="fullPath"/>rolemgmt.flowc','modifyrolemenuop',adjust);//调用统一认证双人授权接口         
			        }else{
			        	adjust();
			        }
		            
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            }
            /**
             * 角色菜单调整返回按钮响应函数
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */
            function menuReturn(){
            	var _mContext = "rolemgmt.jsp -> menuReturn()";
            	try{
					//menuTb.jqDom.hide();
				    //menuPanel.getJqDom().hide();
					//formPanel.getJqDom().show();
					ctp.util.hide(menuTb);
					ctp.util.hide(menuPanel);
					ctp.util.show(formPanel);
					state='info';//改变状态必须在recordClicked调用之前，因recordClicked会判断该标识
					if(grid.getSelectedData()[0]!=null){recordClicked()};//如果表格中选择了某条记录，则执行记录点击响应函数，设置详细信息
            	}catch(e){
            		ctp.core.log.err(_mContext, e.message);
            	}
            } 
        </script>
<script type='text/javascript' kind='notUi'>
            //================================非UI组件定义片段==========================================================
			var roleValidator = new ctp.validator({});//验证框架
        </script>
<script type='text/javascript' kind='ui'>
		    //================================UI组件定义片段============================================================		    
		    //ctp.core.log.lvl = ctp.core.loglvl.obj; //需要进行调试时启用
		    /**
             * 创建UI组件
             * @version	 1.0
             * @since	 1.0
             * @author	KFZX-tangk           
             */		    
		    function initUI(){
		    	 var _mContext = "rolemgmt.jsp -> initUI()";
            	 try {
            	 	 if(hasError){return;}
            		 
                     //创建工具栏上搜索文本框
            		 toolbarSearchT=new ctp.ui.textfield({width: '100px'});
                     //创建工具栏
            		 toolbar=new ctp.ui.toolbar({
						 id : 'roleToolbarId',
						 width: 'auto',			
						 border : 'bottom',			
					     leftItems :[
							 {
							 	id:"btnAdd",
						        type : 'button',
						        text : '<ctp:label key="add_role_btn" />',//新增
						        icon : 'add',
						        onClick : addRole
						     },'-',{
								id:"btnModify",
						        type : 'button',
						        text : '<ctp:label key="modify_role_btn" />',//修改
						        icon : 'edit',
						        onClick : modifyRole
						     },'-',{
								id:"btnDelete",
						        type : 'button',
						        text : '<ctp:label key="delete_role_btn" />',//删除
						        icon : 'delete',
						        onClick : deleteRole
						     },'-',{
								id:"btnAdjust",
							    type : 'button',
							    text : '<ctp:label key="change_role_menu" />',//角色菜单调整
							    icon : 'menu',
							    onClick : adjustMenu
							 },'-',{
								id:"btnReturn",
								type : 'button',
								text : '<ctp:label key="return" />',//返回
								icon : 'back',
								onClick : retFormSubmit
							}
						 ],
					     rightItems :[
							{
								id:"tfSearchId",
						        type : 'textfield',
						        text : '<ctp:label key="search" />：',//搜索
						        object: toolbarSearchT
					        },{
							    id:"btnSearch",
							    type : 'button',
							    icon : 'search',
							    onClick : roleToolbarSearch
						    }
						 ]
					 });
			         //创建角色列表翻页表格
				     grid=new ctp.ui.grid({
				     	 id: 'roleGridId',
						 toolbar:toolbar,
						 toolbarPos:"innertop",
				     	 height: '100%',
				    	 header: {
					     	title:[
								[
									{text: '<ctp:label key="select" />'},//选择
									{text: '<ctp:label key="seqnum" />'},//序号
									{text: '<ctp:label key="role_name" />'},//角色名称
									{text: '<ctp:label key="role_id" />'},//角色编号
									{text: '<ctp:label key="createrole_branch" />'},//创建机构
									{text: '<ctp:label key="role_desc" />'}//角色描述
						        ]
						    ],
						    rowIdFieldName:"id",
						    attr: [
						    	{colType: "radiobox"},
						    	{colType: "seqnum"},
						        {fieldName: "name"},
						        {fieldName: "id"},
						        {fieldName: "branchName"},
						        {fieldName: "description"}
						    ]
						 },
				    	 title: '<ctp:label key="role_list" />',//角色列表
						 url:gridurl,
						 footer:{showRows:7,cacheRows:35}
					 });
					 grid.selectedFn(recordClicked);
     			     //创建表单对象 
     			     lBranch=new ctp.ui.label({width:'100%'});
     			     tId=new ctp.ui.textfield({id: 'roleId',name:'roleId',width:'100%',validate: 'rules[required,letterOrNumber,length[1,20]]'});
     			     tName=new ctp.ui.textfield({id: 'roleName',name:'roleName',width:'100%',validate: 'rules[required,length[1,50],notValidInputText]'});
     			     cgLevel=new ctp.ui.checkboxgroup({id: 'rolel',name:'rolel',itemWidth: '90px',width:'100%',display: 'cols',items: cgItems,validate: 'rules[required]'});
     			     rgPriv=new ctp.ui.radiogroup({
         			 	 id: 'rgpriv',
         			 	 name:'rgpriv',
         			 	 itemWidth: '90px',
         			 	 onChange: privChange,
         			 	 items: [
                 			 {
	             				 id: 'radioNormal',
	             				 label: '<ctp:label key="normal_user" />',//普通用户
	             				 value: 'normal',
	             				 checked: true
             				 }, {
		     		             id: 'radioAll',
		     		             label: '<ctp:label key="all_branch" />',//所有机构
		     		             value: 'all'
     		         		 }, {
		     		             id: 'radioThis',
		     		             label: '<ctp:label key="this_branch" />',//本机构
		     		             value: 'self'
     		         		 }
     		         	 ],
     		         	 width:'100%',
     		         	display: 'cols'
         		     });
     			     cbPriv=new ctp.ui.combobox({id: 'cbpriv',name:'cbpriv',disabled:true,width:'100%',items:cbItems});
     			     taDesc=new ctp.ui.textarea({id: 'description',name:'description',rows:2,width:'100%',validate: 'rules[notValidInputText1,length[0,500]]'});

     			     exclusionMultiselect = new ctp.ui.multiselect({
         			     id: 'exclusionRole',
         			     width: '100%',
         			     lockScreen: true 	
         			 }); 
     			     
     			     //创建角色权限布局
     			     prvLayout=new ctp.ui.gridlayout({
				    	 colSpace: 0,
				    	 cols: 3,
				    	 defaults:{
				     		 align: 'left',
				 	 		 label: {width: '100px'}
				  		 },
				  		 items: [
				  			 [
					  		 	{colspan:2,label:{id: 'lbPriv',text:'<ctp:label key="role_priv" /><span style="color:red;">*</span>:'},element: rgPriv},//角色权限
					  		  	{element: cbPriv}
					  		 ]
				     	 ]
     				 });
                     //创建表单布局器
    				 mlayout=new ctp.ui.gridlayout({
    			         width: '90%',
    			         align: 'center',
    			    	 defaults:{
    			    	 	display: 'h',
    			    	 	align: 'center',
    			    	 	label: {width: '100px'}
    			     	 },
    			     	 colSpace: 30,
    			     	 items: [
    			     		[
     			     			{label:{id: 'lbBranch',text:'<ctp:label key="createrole_branch" />:'},element: lBranch}//创建机构
     			     		],
    			     		[
     			     			{label:{id: 'lbRoleId',text:'<ctp:label key="role_id" /><span style="color:red;">*</span>:'},element: tId},//角色编号
     			     			{label:{id: 'lbRoleName',text:'<ctp:label key="role_name" /><span style="color:red;">*</span>:'},element: tName}//角色名称
     			     		],
    			     		[
     			     			{colspan:2,label:{id: 'lbRoleLevel',text:'<ctp:label key="role_level" /><span style="color:red;">*</span>:'},element: cgLevel}//可使用级别
     			     		],
    			     		[
     			     			{colspan:2,element: prvLayout}
     			     		],
     			     		[
      			     			{colspan:2,label:{id: 'lbExclusion', text: '<ctp:label key="role_exclusion" />:'},element:exclusionMultiselect}
      			     		],
    			      		[
     			      			{colspan:2,label:{id: 'lbDesc',text:'<ctp:label key="role_desc" />:'},element: taDesc}//角色描述
     			      		]
    			     	 ]
    			     }); 
     	             //创建表单
					 form=new ctp.form({
						 id: 'roleForm',
						 width: '90%', //宽度
						 height: 'auto',
						 items: [mlayout],
						 validator:roleValidator,
				   		 postType:'ajax',
				   		 ajaxPostParam:{success: roleFormSucc},
				   		 buttons: [{
				       	 	text: '<ctp:label key="submit" />',//提交
				       		icon:'apply',
				           	onClick: roleFormSubmit
				   		 }, {
				       	    text: '<ctp:label key="reset" />',//重置
				       		icon:'reload',
				       		onClick: roleFormReload
				   		 }]		 
					 });
					 //创建存放表单的面板
					 formPanel=new ctp.ui.panel({
					  	title: '<ctp:label key="role_detail_info" />',//角色详细信息
					  	collapsible: true,
					    width: '100%',
					    //height: 'auto',
					    height: '100%',
					    //visible: 'visible',
					    items: [form]
					 });
					 
					 //创建返回表单
					 retform=new ctp.form({
						 id: 'roleRetform',
						 width: '90%', //宽度
				   		 postType:'normal'
					 });
					 //创建角色菜单调整工具栏
					 menuTb = new ctp.ui.toolbar({
					 	id : 'toolbarId2',
						width: 'auto',			
						border : 'bottom',			
					    leftItems :[
							{
						    	type : 'button',
								text : '<ctp:label key="confirm" />',//确定
								icon : 'apply',
								useable : true,
								onClick : menuConfirm
							},'-',{
							    type : 'button',
							    text : '<ctp:label key="return" />',//返回
							    icon : 'back',
							    useable : true,
							    onClick : menuReturn
							}
						]
					});
					 //创建角色菜单表格树
					 tableTree=new ctp.ui.tabletree({
         				remember: 'yes',
         				width: '100%',
         				height: '100%',
         				actionPos: 1,
         				tableHead:[
         	         		[
          	         			{text:'<ctp:label key="module_name"/>'},//功能名称
          	         			{text:'<ctp:label key="module_code"/>'},//功能编号
          	         			{text:'<ctp:label key="state"/>'},//激活状态
          	         			{text:'<ctp:label key="auth"/>',edit:{fieldName:'auth',fieldType:'select',config:{options:{items:[{text:'<ctp:label key="first_use"/>',value:'1'},{text:'<ctp:label key="forbid"/>',value:'0'},{text:'<ctp:label key="can_select"/>',value:'-1'}]}}}}//权限
          	         		]
          	         	],
         				tableInJson:[]
         			});
	         		//创建存放角色菜单的面板
         			menuPanel=new ctp.ui.panel({
         				title: '<ctp:label key="change_role_menu"/>',//角色菜单调整
         				toolbar:menuTb,
         				toolbarPos:"innertop",
         				collapsible: true,
         				width: '100%',
         				//height: 'auto',
         				height: '100%',
         				bodyPadding: '0',
         				//visible: 'visible',
         				items: [tableTree]
         			});

         			//创建页面上下布局
           		 layout=new ctp.ui.borderlayout({
                        type: "2E",
                        north__size: 0.5,       
                        north__items:[grid],
                        center__items:[formPanel,menuPanel],
                        renderTo:"body"
                    }); 

            	}	
            	catch (e) {
                     ctp.core.log.err(_mContext, e.message);
                }
		    }   
		</script>
</head>
<body onload='init();initUI();queryExtProperty();displayFinish();'>
<ctp:form name="roleForm" method="post" action="rolemgmt.flowc"
	flowActionName="">
	<input type="hidden" name="branchId" />
	<input type="hidden" name="privilegeSelf" />
	<input type="hidden" name="privilegeAll" />
	<input type="hidden" name="privilegeOther" />
	<input type="hidden" name="roleLevel" />
	<input type="hidden" name="ext_flag" />
	<input type="hidden" name="objId" />
	<input type="hidden" name="json.refRoleExclu" id='refRoleExclu' />
</ctp:form>
<ctp:form name="roleRetform" method="post" action="rolemgmt.flowc"
	flowActionName="retop">
</ctp:form>
</body>
</html>

<%--
	date        :
	modifyReason:
--%>